System and method for information lifecycle workflow integration

ABSTRACT

A system and method for submitting information to a lifecycle in a virtual content repository (VCR), comprising, defining the lifecycle wherein the definition includes a plurality states and one or more transitions to interconnect and impose an order on the plurality of states, providing to a first process access to the lifecycle wherein the first process can cause the information to transition from a first state of the plurality of states to a second state of the plurality of states according to a first transition of the one or more transitions, wherein the information is accessible through a logical namespace that encompasses the VCR, and wherein the information can include at least one of: content and schema information.

CLAIM OF PRIORITY

This application claims priority from the following application, whichis hereby incorporated by reference in its entirety:

SYSTEM AND METHOD FOR INFORMATION LIFECYCLE WORKFLOW INTEGRATION, U.S.application Ser. No. 60/561,646, Inventors: Rodney McCauley et al.,filed on Apr. 13, 2004. (Attorney's Docket No. BEAS-01555US0)

COPYRIGHT NOTICE

A portion of the disclosure of this patent document contains materialwhich is subject to copyright protection. The copyright owner has noobjection to the facsimile reproduction by anyone of the patent documentor the patent disclosure, as it appears in the Patent and TrademarkOffice patent file or records, but otherwise reserves all copyrightrights whatsoever.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is related to the following co-pending applicationswhich are each hereby incorporated by reference in their entirety:

SYSTEM AND METHOD FOR DELEGATED ADMINISTRATION, U.S. patent applicationSer. No. 10/279,543, Filed on Oct. 24, 2002, Inventors: Philip B.Griffin, et al., (Attorney's Docket No. BEAS-1157US0)

SYSTEM AND METHOD FOR RULE-BASED ENTITLEMENTS, U.S. patent applicationSer. No. 10/279,564, Filed on Oct. 24, 2002, Inventors: Philip B.Griffin, et al., (Attorney's Docket No. BEAS-1158US0)

SYSTEM AND METHOD FOR HIERARCHICAL ROLE-BASED ENTITLEMENTS, U.S. patentapplication Ser. No. 10/367,177, filed on Feb. 14, 2003, Inventors:Philip B. Griffin, et al., (Attorney's Docket No. BEAS-1353US0)

METHOD FOR ROLE AND RESOURCE POLICY MANAGEMENT, U.S. patent applicationSer. No. 10/367,462 filed on Feb. 14, 2003, Inventors: Philip B.Griffin, et al., (Attorney's Docket No. BEAS-1356US0)

METHOD FOR ROLE AND RESOURCE POLICY MANAGEMENT OPTIMIZATION, U.S. patentapplication Ser. No. 10/366,778, filed on Feb. 14, 2003, Inventors:Philip B. Griffin, et al., (Attorney's Docket No. BEAS-1357US0)

METHOD FOR DELEGATED ADMINISTRATION, U.S. patent application Ser. No.10/367,190, filed on Feb. 14, 2003, Inventors: Philip B. Griffin, et al.(Attorney's Docket No. BEAS-1358US0)

VIRTUAL CONTENT REPOSITORY APPLICATION PROGRAM INTERFACE, U.S. patentapplication Ser. No. 10/618,494, filed on Jul. 11, 2003, Inventors:James Owen, et al., (Attorney's Docket No. BEAS-1370US0)

SYSTEMS AND METHODS FOR PORTAL AND WEB SERVER ADMINISTRATION, U.S.patent application Ser. No. 10/786,742, Inventors: Christopher Bales, etal., filed on Feb. 25, 2004. (Attorney's Docket No. BEAS-1371US1)

METHODS FOR DELEGATED ADMINISTRATION, U.S. patent application Ser. No.10/819,043, filed on Apr. 6, 2004, Inventors: Manish Devgan, et al.,(Attorney's Docket No. BEAS-153 8US0)

FEDERATED MANAGEMENT OF CONTENT REPOSITORIES, U.S. patent applicationSer. No. 10/618,513, filed on Jul. 11, 2003, Inventors: James Owen, etal., (Attorney's Docket No. BEAS-1360US1)

VIRTUAL REPOSITORY CONTENT MODEL, U.S. patent application Ser. No.10/618,519, filed on Jul. 11, 2003, Inventors: James Owen, et al.,(Attorney's Docket No. BEAS-1361US1)

VIRTUAL CONTENT REPOSITORY BROWSER, U.S. patent application Ser. No.10/618,379, filed on Jul. 11, 2003, Inventors: Jalpesh Patadia, et al.,(Attorney's Docket No. BEAS-1362US0)

SYSTEM AND METHOD FOR A VIRTUAL CONTENT REPOSITORY, U.S. patentapplication Ser. No. 10/618,495, filed on Jul. 11, 2003, Inventors:James Owen, et al., (Attorney's Docket No. BEAS-1363US0)

VIRTUAL REPOSITORY COMPLEX CONTENT MODEL, U.S. patent application Ser.No. 10/618,380, filed on Jul. 11, 2003, Inventors: James Owen, et al.,(Attorney's Docket No. BEAS-1364US0)

SYSTEM AND METHOD FOR SEARCHING A VIRTUAL REPOSITORY CONTENT, U.S.patent application Ser. No. 10/619,165, filed on Jul. 11, 2003,Inventor: Gregory Smith, (Attorney's Docket No. BEAS-1365US0)

SYSTEM AND METHOD FOR CONTENT VERSIONING, U.S. patent application Ser.No. ______, filed on ______, Inventors: Rodney McCauley, et al.,(Attorney's Docket No. BEAS-1533US1)

SYSTEM AND METHOD FOR CONTENT LIFECYCLES, U.S. patent application Ser.No. ______, filed on ______, Inventors: Rodney McCauley, et al.,(Attorney's Docket No. BEAS-1534US1)

SYSTEM AND METHOD FOR CONTENT AND SCHEMA VERSIONING, U.S. patentapplication Ser. No. ______, filed on ______, Inventors: RodneyMcCauley, et al., (Attorney's Docket No. BEAS-1535US1)

SYSTEM AND METHOD FOR CONTENT AND SCHEMA LIFECYCLES, U.S. patentapplication Ser. No. ______, filed on ______, Inventors: RodneyMcCauley, et al., (Attorney's Docket No. BEAS-1536US1)

SYSTEM AND METHOD FOR VIRTUAL CONTENT REPOSITORY DEPLOYMENT, U.S. patentapplication Ser. No. ______, filed on ______, Inventors: RodneyMcCauley, et al., (Attorney's Docket No. BEAS-1550US1)

SYSTEM AND METHOD FOR VIRTUAL CONTENT REPOSITORY ENTITLEMENTS, U.S.patent application Ser. No. ______, filed on ______, Inventors: RodneyMcCauley, et al., (Attorney's Docket No. BEAS-1551US1)

SYSTEM AND METHOD FOR CONTENT TYPE MANAGEMENT, U.S. patent applicationSer. No. ______, filed on ______, Inventors: Rodney McCauley, et al.,(Attorney's Docket No. BEAS-1552US1)

SYSTEM AND METHOD FOR CUSTOM CONTENT LIFECYCLES, U.S. patent applicationSer. No. ______, filed on ______, Inventors: Rodney McCauley, et al.,(Attorney's Docket No. BEAS-1553US1)

SYSTEM AND METHOD FOR CONTENT TYPE VERSIONS, U.S. patent applicationSer. No. ______, filed on ______, Inventors: Rodney McCauley, et al.,(Attorney's Docket No. BEAS-1554US1)

SYSTEM AND METHOD FOR BATCH OPERATIONS IN A VIRTUAL CONTENT REPOSITORY,U.S. patent application Ser. No. ______, filed on ______, Inventors:Rodney McCauley, et al., (Attorney's Docket No. BEAS-1556US1)

SYSTEM AND METHOD FOR VIEWING A VIRTUAL CONTENT REPOSITORY, U.S. patentapplication Ser. No. ______, filed on ______,Inventors: Rodney McCauley,et al., (Attorney's Docket No. BEAS-1557US1)

SYSTEM AND METHOD FOR SEARCHING A VIRTUAL CONTENT REPOSITORY, U.S.patent application Ser. No. ______, filed on ______, Inventors: RodneyMcCauley, et al., (Attorney's Docket No. BEAS-1565US1)

SYSTEM AND METHOD FOR PROVIDING CONTENT SERVICES TO A REPOSITORY, U.S.patent application Ser. No. ______, filed on ______, Inventors: RodneyMcCauley, et al., (Attorney's Docket No. BEAS-1729US0)

FIELD OF THE DISCLOSURE

The present invention disclosure relates to content management, and inparticular, versioning content and providing definable contentlifecycles.

BACKGROUND

Content repositories manage and provide access to large data stores suchas a newspaper archives, advertisements, inventories, image collections,etc. A content repository can be a key component of a web applicationsuch as a portal, which must quickly serve up different types of contentin response to user interaction. However, difficulties can arise whentrying to integrate more than one vendor's content repository. Each mayhave its own proprietary application program interface and contentservices (e.g., conventions for searching and manipulating content,versioning, lifecycles, and data formats). Furthermore, each time arepository is added to an application, the application software must bemodified to accommodate these differences. What is needed is a coherentsystem and method for interacting with disparate repositories and forproviding a uniform set of content services across all repositories,including those that lack such services.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an exemplary illustration of functional system layers invarious embodiments of the invention.

FIG. 2 is an exemplary illustration of a lifecycle in variousembodiments of the invention.

FIG. 3 is an exemplary illustration of an external scenario that invokesa lifecycle in various embodiments.

FIG. 4 is an exemplary user interface in various embodiments of theinvention.

FIG. 5 is an exemplary illustration of objects/interfaces that can beused in connecting a repository to a VCR in various embodiments of theinvention.

FIG. 6 is an exemplary illustration of objects/interfaces that can beused as service model in various embodiments of the invention.

FIG. 7 is an exemplary illustration of content creation while VCRcontent services are disabled in accordance to various embodiments ofthe invention.

FIG. 8 is an exemplary illustration of content creation while VCRcontent services are enabled in accordance to various embodiments of theinvention.

FIG. 9 is an exemplary illustration of modifying a node in the VCR whilecontent services are enabled in accordance to various embodiments of theinvention.

FIG. 10 is an exemplary illustration of publishing a node in the VCRwhile content services are enabled in accordance to various embodimentsof the invention.

FIG. 11 is an exemplary illustration of retiring a node in the VCR whilecontent services are enabled in accordance to various embodiments of theinvention.

DETAILED DESCRIPTION

Aspects of the invention are illustrated by way of example and not byway of limitation in the FIGS. of the accompanying drawings in whichlike references indicate similar elements. It should be noted thatreferences to “an”, “one” and “various” embodiments in this disclosureare not necessarily to the same embodiment, and such references mean atleast one. If the following description, numerous specific details areset forth to provide a thorough description of the invention. However,it will be apparent to one skilled in the art that the invention may bepracticed without these specific details. In other instances, well-knownfeatures have not been described in detail so as not to obscure theinvention.

FIG. 1 is an exemplary illustration of functional system layers invarious embodiments of the invention. Although this diagram depictscomponents as logically separate, such depiction is merely forillustrative purposes. It will be apparent to those skilled in the artthat the components portrayed in this FIG. can be arbitrarily combinedor divided into separate software, firmware and/or hardware.Furthermore, it will also be apparent to those skilled in the art thatsuch components, regardless of how they are combined or divided, canexecute on the same computing device or can be distributed amongdifferent computing devices connected by one or more networks or othersuitable communication means.

A content repository 112 represents a searchable data store. Suchsystems can relate structured content and unstructured content (e.g.,digitally scanned paper documents, Extensible Markup Language, PortableDocument Format, Hypertext Markup Language, electronic mail, images,video and audio streams, raw binary data, etc.) into a searchablecorpus. Content repositories can be coupled to or integrated withcontent management systems. Content management systems can provide forcontent life cycle management, versioning, content review and approval,automatic content classification, event-driven content processing,process tracking and content delivery to other systems. By way ofillustration, if a user fills out a loan application on a web portal,the portal can forward the application to a content repository which, inturn, can contact a bank system, receive notification of loan approval,update the loan application in the repository and notify the user byrendering the approval information in a format appropriate for the webportal.

A virtual or federated content repository (hereinafter referred to as“VCR”) is a logical representation of one or more individual contentrepositories such that they appear and behave as a single contentrepository from the standpoint of application layer 120. The VCR canalso add content services to repositories that natively lack them. Invarious embodiments and by way of illustration, this can be accomplishedin part by use of an API (application program interface) 100 and an SPI(service provider interface) 102. An API describes how entities in theapplication layer can interface with some program logic orfunctionality. The application layer can include applications (andsubdivisions thereof) that utilize the API, such as processes, threads,servlets, portlets, objects, libraries, and other suitable applicationcomponents. An SPI describes how a service provider (e.g., a contentrepository, a content management system) can be integrated into a systemof some kind. The SPI isolates direct interaction with repositories fromthe API. In various embodiments, this can be accomplished at run-timewherein the API library dynamically links to or loads the SPI library.In another embodiment, the SPI can be part of a server process such thatthe API and the SPI can communicate over a network. The SPI cancommunicate with the repositories using any number of means including,but not limited to, shared memory, remote procedure calls and/or via oneor more intermediate server processes.

API's and SPI's can be specified as a collection of classes/interfaces,data structures and/or methods/functions that work together to provide aprogrammatic means through which VCR service(s) can be accessed andutilized. By way of illustration, APIs and SPIs can be specified in anobject-oriented programming language, such as Java™ (available from SunMicrosystems, Inc. of Mountain View, Calif.) and C# (available fromMicrosoft Corp. of Redmond, Wash.). The API and SPI can be exposed in anumber of ways, including but not limited to static libraries, dynamiclink libraries, distributed objects, servers, class/interface instances,and other suitable means.

In various embodiments, the API presents a unified view of allrepositories to the application layer such that navigation, CRUDoperations (create, read, update, delete), versioning, lifecycles, andsearching operations initiated from the application layer operate on therepositories as though they were one. Repositories that implement theSPI can “plug into” the VCR. The SPI includes a set of interfaces andservices that support API functionality at the repository level. The APIand SPI share a content model that represents the combined content ofall repositories as a hierarchical namespace of nodes. Given a node N,nodes that are hierarchically inferior to N are referred to as childrenof N, whereas nodes that are hierarchically superior to N are referredto as parents of N. The top-most level of the hierarchy is termed thefederated root. There is no limit to the depth of the hierarchy. Invarious embodiments, repositories are children of the federated root.Each repository can itself have children.

By way of illustration, content mining facilities 104, processes/threads106, tag libraries 108, integrated development environments (IDEs) 110,and other libraries 118 can all utilize the API to interact with a VCR.An IDE can provide the ability for a user to interactively buildlifecycles and/or content views. Content mining facilities can includeservices for automatically extracting content from the VCR based onparameters. Java ServerPages™ tag libraries enable portals to interactwith the VCR and surface its content on web pages. (Java ServerPages™ isavailable from Sun Microsystems, Inc.) In addition, it will be apparentto those of skill in the art that many other types of applications andsoftware components utilize the API and are, as such, fully within thescope and spirit of the present disclosure.

In various embodiments, the API can include optimizations to improve theperformance of interacting with the VCR. One or more caches 116 can beused to buffer search results and/or recently accessed nodes. In variousembodiments, a cache can include a node cache and/or a binary cache. Anode cache can be used to provide fast access to recently accessed nodeswhereas a binary cache can be used to provide fast access to thecontent/data associated with each node in a node cache. The API can alsoprovide a configuration facility 114 to enable applications, tools andlibraries to configure caches and the VCR. In various embodiments, thisfacility can be implemented as a Java Management Extension (availablefrom Sun Microsystems, Inc.).

In various embodiments, a model for representing hierarchy information,content and data types is shared between the API and the SPI. In thismodel, a node can represent hierarchy information, content or a schemainformation. Hierarchy nodes can serve as a containers for other nodesin the namespace akin to a file subdirectory in a hierarchical filesystem. Schema nodes represent predefined data types. Content nodesrepresent content/data. Nodes can have a shape defined by theirproperties. A property associates a name, a data type and an optional avalue which is appropriate for the type. In certain of theseembodiments, the properties of content nodes contain values. By way ofan illustration, a type can be any of the types described in Table 1.Those of skill in the art will appreciate that many more types arepossible and fully within the scope and spirit of the presentdisclosure. TABLE 1 Exemplary Property Types in Various EmbodimentsPROPERTY TYPE DESCRIPTION Basic Text, a number, a date/time, a Booleanvalue, a choice, an image, a sound, a bit mask, an audio/visualpresentation, binary data. Schema The property is defined based on aschema node. Link A pointer/reference to data that lives “outside” of anode. Lookup An expression to be evaluated for locating another node inthe VCR Database Maps to an existing database table or view. Mapped

In various embodiments, a property can also indicate whether it isrequired, whether it is read-only, whether it provides a default value,and whether it specifies a property choice. A property choice indicatesif a property is a single unrestricted value, a single restricted value,a multiple unrestricted value, or a multiple restricted value.Properties that are single have only one value whereas properties thatare multiple can have more than one value. If a property is restricted,its value(s) are chosen from a finite set of values. But if a propertyis unrestricted, any value(s) can be provided for it. A property canalso be designated as a primary property. By way of illustration, theprimary property of a node can be considered its default content. Forexample, if a node contained a binary property to hold an image, itcould also contain a second binary property to represent a thumbnailview of the image. If the thumbnail view was the primary property,software applications such as browser could display it by default.

A named collection of one or more property types is a schema. A schemanode is a place holder for a schema. In various embodiments, schemas canbe used to specify a node's properties. By way of illustration, a Personschema with three properties (Name, Address and DateofBirth) can bedescribed for purposes of discussion as follows: Schema Person = {   <Name=Name, Type=Text>,    <Name=Address, Type=Address>,   <Name=DateofBirth, Type=Date>}

Various embodiments allow a node to be defined based on a schema. By wayof illustration, a content node John can be given the same properties asthe schema Person:

-   -   Content Node John is a Person

In this case, the node John would have the following properties: Name,Address and DateofBirth. Alternatively, a node can use one or moreschemas to define individual properties. This is sometimes referred toas nested types. In the following illustration, John is defined havingan Info property that itself contains the properties Name, Address andDateofBirth. In addition, John also has a CustomerId property: ContentNode John = {   <Name=Info, Type=Person>,   <Name=CustomerId,Type=Number> }

Schemas can be defined logically in the VCR and/or in the individualrepositories that form the VCR. In certain embodiments, schemas caninherit properties from at least one other schema. Schema inheritancecan be unlimited in depth. That is, schema A can inherit from schema B,which itself can inherit from schema C, and so on. If several schemascontain repetitive properties, a “base” schema can be configured fromwhich the other schemas can inherit. For example, a Person schemacontaining the properties Name, Address and DateofBirth, can beinherited by an Employee schema which adds its own properties (i.e.,Employee ID, Date of Hire and Salary): Schema Employee inherits fromPerson = {   <Name=EmployeeID, Type= Number>,   <Name=DateofHire,Type=Date>,   <Name=Salary, Type= Number> }

Thus, as defined above the Employee schema has the following properties:Name, Address, DateofBirth, EmployeeID, DateofHire and Salary. If thePerson schema had itself inherited properties from another schema, thoseproperties would also belong to Employee.

In various embodiments, nodes have names/identifiers and can bespecified programmatically or addressed using a path that designates thenode's location in a VCR namespace. By way of illustration, the path canspecify a path from the federated root (‘/’) to the node in question(‘c’):

-   -   /a/b/c

In this example, the opening ‘/’ represents the federated root, ‘a’represents a repository beneath the federated root, ‘b’ is a hierarchynode within the ‘a’ repository, and ‘c’ is the node in question. Thepath can also identify a property (“property1”) on a node:

-   -   /a/b/c.property1

In aspects of these embodiments, the path components occurring prior tothe node name can be omitted if the system can deduce the location ofthe node based on context information.

In various embodiments, a schema defined in one repository or the VCRcan inherit from one or more schemas defined in the same repository, adifferent repository or the VCR. In certain aspects of theseembodiments, if one or more of the repositories implicated by aninherited schema do not support inheritance, the inheriting schema canbe automatically defined in the VCR by the API. In one embodiment, theinheriting schema is defined in the VCR by default.

By way of illustration, the Employee schema located in the Avitechrepository inherits from the Person schema located beneath the Schemashierarchy node in the BEA repository: Schema /Avitech/Employee inheritsfrom /BEA/Schemas/Person = {   <Name=EmployeeID, Type= Number>,  <Name=DateofHire, Type=Date>,   <Name=Salary, Type= Number> }

In various embodiments, the link property type (see Table 1) allows forcontent reuse and the inclusion of content that may not be under controlof the VCR. By way of illustration, the value associated with a linkproperty can refer/point to any of the following: a content node in aVCR, an individual property on a content node in a VCR, a file on a filesystem, an objected identified by a URL (Uniform Resource Locator), orany other suitable identifier. In various embodiments, when editing acontent node that has a link property type, a user can specify the linkdestination (e.g., using a browser-type user interface). In certainaspects of these embodiments, if a link refers to a content node or acontent node property that has been moved, the link can be automaticallybe resolved by the system to reflect the new location.

In various embodiments, a value whose type is lookup (see Table 1) canhold an expression that can be evaluated to search the VCR for instancesof content node(s) that satisfy the expression. Nodes that satisfy theexpression (if any) can be made available for subsequent processing. Invarious embodiments, a lookup expression can contain one or moreexpressions that can substitute expression variables from: the contentnode containing the lookup property, a user profile, anything in thescope of a request or a session. In various embodiments, an expressioncan include mathematical, logical and Boolean operators, function/methodinvocations, macros, SQL (Structured Query Language), and any othersuitable query language. In various embodiments, an expression can bepre-processed one or more times to perform variable substitution,constant folding and/or macro expansion. It will be apparent to those ofskill in the art that many other types of expressions are possible andfully within the scope and spirit of this disclosure.

In various embodiments, when editing a content node that has a lookupproperty type, the user can edit the expression through a user interfacethat allows the user to build the expression by either entering itdirectly and/or by selecting its constituent parts. In addition, theuser interface can enable the user to preview the results of theexpression evaluation.

Database mapped property types (see Table 1) allow information to beculled (i.e., mapped) from one or more database tables (or otherdatabase objects) and manipulated through node properties. By way ofillustration, a company might have “content” such as news articlesstored as rows in one or more RDBMS (Relational Database ManagementSystem) tables. The company might wish to make use of this “content” viatheir portal implementation. Further, they might wish to manage theinformation in this table as if it existed in the VCR. Onceinstantiated, a content node property that is of the database mappedtype behaves as though its content is in the VCR (rather than thedatabase table). In one embodiment, all API operations on the propertybehave the same but ultimately operate on the information in thedatabase table.

In various embodiments, a given database mapped property type can havean expression (e.g., SQL) which, when evaluated, resolves to a row and acolumn in a database table (or resolves to any kind of database object)accessible by the system over one or more networks. A database mappedproperty will be able to use either native database tables/objects ordatabase views on those tables/objects. It will be appreciated by thoseof skill in the art that the present disclosure is not limited to anyparticular type of database or resolving expression.

In aspects of certain embodiments, a schema can be automatically createdthat maps to any row in a database table. The system can inspect thedata structure of the table and pre-populate the schema with databasemapped properties corresponding to columns from the table. The tablecolumn names can be used as the default property names and likewise thedata type of each column will determine the data type of eachcorresponding property. The system can also indicate in the schema whichproperties correspond to primary key columns. If certain columns fromthe table are not to be used in the new schema, they can be un-mapped(i.e. deselected) by a user or a process. A content node can be based onsuch a schema and can be automatically bound to a row in a databasetable (or other database object) when it is instantiated. In variousembodiments, a user can interactively specify the database object bybrowsing the database table.

In various embodiments, a display template (or “template”) can be usedto display content based on a schema. Templates can implement various“views”. By way of illustration, views could be “full”, “thumbnail”, and“list” but additional “views” could be defined by end-users. A full viewcan be the largest, or full page view of the content. A thumbnail viewwould be a very small view and a list view can be used when displayingmultiple content nodes as a “list” on the page (e.g., a product catalogsearch results page). In various embodiments, the association between aschema and templates can be one-to-many. A template can be designated asthe default template for a schema. In certain of these embodiments,templates can be designed with the aid of an integrated developmentenvironment (IDE).

In various embodiments and by way of a illustration, display templatescan be implemented using HTML (Hypertext Markup Language) and JSP (Java®Server Pages). By way of a further illustration, such a display templatecan be accessed from a web page through a JSP tag which can accept as anargument the identifier of a content node. Given the content node, thenode's schema and associated default display template can be derived andrendered. Alternatively, the JSP tag can take an additional argument tospecify a view other than the default. In another embodiment, displaytemplates can be automatically generated (e.g., beforehand ordynamically at run-time) based on a content node's schema. In otherembodiments, the view (e.g., full, thumbnail, list) can be determinedautomatically based on the contents of an HTTP request.

In various embodiments, a role is a dynamic set of users. By way ofillustration, a role can be based on functional responsibilities sharedby its members. In aspects of these embodiments, a role can be definedby one or more membership criteria. Role mapping is the process by whichit is determined whether or not a user satisfies the membership criteriafor a given role. For purposes of discussion, a role can be described asfollows:Role=PMembers+[Membership Criteria]

where PMembers is a set of user(s), group(s) and/or other role(s) thatform a pool of potential members of this role subject to the MembershipCriteria, if any. For a user or a process to be in a role, they mustbelong to PMembers and satisfy the Membership Criteria. The MembershipCriteria can include one or more conditions. By way of illustration,such conditions can include, but are not limited to, one or more(possibly nested and intermixed) Boolean, mathematical, functional,relational, and/or logical expressions. By way of illustration, considerthe following Administrator role:Administrator=Joe, Mary, SuperUser+CurrentTime>5:00pm

The role has as its potential members two users (Joe and Mary) and usersbelonging to the user group named SuperUser. The membership criteriaincludes a condition that requires the current time to be after 5:00 pm.Thus, if a user is Joe, Marry or belongs to the SuperUser group, and thecurrent time is after 5:00 pm, the user is a member of the Administratorrole.

In various embodiments, roles can be associated with Resource(s). By wayof illustration, a resource can be any system and/or application asset(e.g., VCR nodes and node properties, VCR schemas and schema properties,operating system resources, virtual machine resources, J2EE applicationresources, and any other entity that can be used by or be a part ofsoftware/firmware of some kind). Typically, resources can be arranged inone or more hierarchies such that parent/child relationships areestablished (e.g., the VCR hierarchical namespace and the schemainheritance hierarchy). In certain of these embodiments, a containmentmodel for roles is followed that enables child resources to inheritroles associated with their parents. In addition, child resources canoverride their parents' roles with roles of their own.

In various embodiments, Membership Criteria can be based at leastpartially on a node's properties. This allows for roles that can compareinformation about a user/process to content in the VCR, for example. Invarious embodiments, a node's property can be programmatically accessedusing dot notation: Article.Creator is the Creator property of theArticle node. By way of illustration, assume an Article node thatrepresents a news article and includes two properties: Creator andState. A system can automatically set the Creator property to the nameof the user that created the article. The State property indicates thecurrent status of the article from a publication lifecycle standpoint(e.g., whether the article is a draft or has been approved forpublication). In this example, two roles are defined (see Table 2).TABLE 2 Exemplary Roles in an Embodiment ROLE ASSOCIATED MEMBERSHIP NAMEWITH PMEMBERS CRITERIA Submitter Article Article.Creator Article.State =Draft Approver Article Editor Article.State = (Submitted or Approved)

The Submitter and Approver roles are associated with the Article node.Content nodes instantiated from this schema will inherit these roles. Ifa user attempting to access the article is the article's creator and thearticle's state is Draft, the user can be in the Submitter role.Likewise, if a user belongs to an Editor group and the article's stateis Submitted or Approved, then the user can belong to the Approver role.

In various embodiments, a policy can be used to determine whatcapabilities or privileges for a given resource are made available tothe policy's Subjects (e.g., user(s), group(s) and/or role(s)). Forpurposes of discussion, a policy can be described as follows:Policy=Resource+Privilege(s)+Subjects+[Policy Criteria]

Policy mapping is the process by which Policy Criteria, if any, areevaluated to determine which Subjects are granted access to one or morePrivileges on a Resource. Policy Criteria can include one or moreconditions. By way of illustration, such conditions can include, but arenot limited to, one or more (possibly nested and intermixed) Boolean,mathematical, functional, relational, and/or logical expressions.Aspects of certain embodiments allow policy mapping to occur just priorto when an access decision is rendered for a resource.

Similar to roles, in certain of these embodiments a containment modelfor policies is followed that enables child resources to inheritpolicies associated with their parents. In addition, child resources canoverride their parents' polices with policies of their own.

In various embodiments, policies on nodes can control access toprivileges associated with the nodes. By way of illustration, given thefollowing policies:Policy1=Printer504+Read/View+MarketingPolicy2=Printer504+All+Engineering

the Marketing role can read/view and browse the Printer504 resourcewhereas the Engineering role has full access to it (“All”). Theseprivileges are summarized in Table 3. Policy1 allows a user in theMarketing role to merely view the properties of Printer504 whereasPolicy2 allows a user in the Engineering role to view and modify itsproperties, to create content nodes based on Printer504 (assuming it isa schema), and to delete the resource. TABLE 3 Exemplary Privileges foran “Printer504” Node in Various Embodiments READ/ ROLE CREATE VIEWUPDATE DELETE BROWSE Marketing x x Engineering x x x x x

Aspects of certain of these embodiments include an implied hierarchy forprivileges wherein child privilege(s) of a parent privilege areautomatically granted if the parent privilege is granted by a policy. Byway of illustration, the Browse privilege can be considered the leastdominant of the privileges for the Printer504 node. Addition of anyother privilege will implicitly includes Browse. For example, if thenext step up is the Read/View capability, selection of Read/View willimplicitly include the Browse privilege.

In various embodiments, the containment models for polices and roles areextended to allow the properties of a node to inherit the policies androles that are incident on the node. Roles/polices on properties canalso override inherited roles/polices. For purposes of illustration,assume the following policy on a Power property of Printer504:Policy3=Printer504.Power+Update+Marketing

In Policy3, the Marketing role is granted the right to update the Powerproperty for the printer resource Printer504 (e.g., control whether theprinter is turned on or off). By default, the Read/View property is alsogranted according to an implied privilege hierarchy. (There is no Browseprivilege for this property.) See Table 4. Alternatively, if there wasno implied privilege hierarchy, the Power property would inherit theread/view privilege for the Marketing role from its parent, Printer504.Although no policy was specified for the Power property and theEngineering role, the privileges accorded to the Engineering role can beinherited from a parent node. These privileges are summarized in Table4. TABLE 4 Exemplary Privileges for the “Power” Property in the“Printer504” Node ROLE CREATE READ/VIEW UPDATE DELETE Marketing x xEngineering x x x x

In various embodiments, the ability to instantiate a node based on aschema can be privileged. This can be used to control which types ofcontent can be created by a user or a process. By way of illustration,assume the following policy:Policy4=Press_Release+Instantiate+Marketing, Manager

Policy4 specifies that nodes created based on the schema Press_Releasecan only be instantiated by users/processes who are members of theMarketing and/or Manager roles. In aspects of certain of theseembodiments, user interfaces can use knowledge of these policies torestrict available user choices (e.g., users should only be able to seeand choose schemas on which they have the Instantiate privilege).

In various embodiments, policies can be placed on schemas. Instances ofa schemas (e.g., content nodes), can inherit these policies unlessoverridden by a more local policy. For purposes of illustration, assumethe following policies:Policy5=Press_Release+Read/View+EveryonePolicy6=Press_Release+All+Public_Relations

TABLE 5 Exemplary Privileges for the “Press Release” Schema CREATE READ/ROLE INSTANCE VIEW UPDATE DELETE BROWSE Everyone X x Public x X x x xRelations

With reference to Table 5 and by way of illustration, assume a contentnode instance was created based on the Press Release schema. By default,it would have the same roles/polices as the Press Release schema. If apolicy was added to the node giving a role “Editor” the privilege toupdate the node, the result would be additive. That is, Everyone andPublic Relations would maintain their original privileges.

In various embodiments, policies can be placed on properties within aschema, including property choices. (Property choices are apredetermined set of allowable values for a given property. For example,a “colors” property could have the property choices “red”, “green” and“blue”.) Instances of a schemas (e.g., in content nodes), would inheritthese property policies unless overridden by a more local policy.

In various embodiments, content and schema nodes can follow lifecycles.In certain aspects of these embodiments, a lifecycle can set forth: aset of states through which a node can pass; actions that can occur aspart of or resulting from state transitions; and actors that canparticipate in the lifecycle. By way of illustration, lifecycles can beused to model an organization's content approval process. In variousembodiments, lifecycles can be nested within lifecycles. This allows forcomplex lifecycles to be compartmentalized for easy manipulation anddevelopment. Various embodiments include a lifecycle definition, anextensible lifecycle system, an interactive lifecycle design tool togenerate and/or modify lifecycle definitions, and means for lifecyclesto interact with other systems. If a content repository does notnatively support lifecycles, support can be provided by the VCR.

In various embodiments, a lifecycle can be associated with, or be aproperty of, a node. In aspects of these embodiments, if a lifecycle isassociated with a hierarchy node, the children of the hierarchy nodewill also be associated with the lifecycle. Likewise, if a lifecycle isassociated with a schema, nodes instantiated based on the schema willalso be associated with the lifecycle. Lifecycles can also be directlyassociated with content nodes.

In various embodiments and by way of illustration, a node can transitionfrom a current state to a new state. Before, during or after atransition, one or more actions can be performed. Actions can optionallyoperate on and/or utilize the node. Actions can include any type ofprocessing that can be invoked in the course of the lifecycle. By way ofan example, actions can include function/method calls, remote procedurecalls, inter-process communication, intra-process communication,interfacing with hardware devices, checking a node into/out of versioncontrol, assigning the node to a user, group or role, performing somekind of processing on the node (depending on any policies that may bedefined on the node), providing a notification to users, groups and/orroles, and other suitable processing. Actions can also be specified ascommand(s), directive(s), expression(s) or other constructs that can beinterpreted or mapped to identify required processing. For example,high-level action directives such as “publish” could cause a contentnode to be published, and an e-mail or other message to be sent tocertain parties. It will be apparent to those of skill in the art thatany action is within the scope and the spirit of the present disclosure.

An exemplary lifecycle for a content node representing a news article isillustrated in Table 6 and FIG. 2. States are illustrated in FIG. 2 asdocument icons (204, 208, 212, 216) and decision points between statesare illustrated as circles (206, 210, 214). Transitions between statesare illustrated as lines that are directed to show the order of states.In aspects of certain of these embodiments, transitions between statescan pass through one or more decision points. A decision point is avisual placeholder (e.g., an icon in an IDE graphical editor) forrestricting transitions to user(s), groups(s), and role(s); and forspecifying action(s) that can accompany a change in state, if any. Adecision point can connect a state to at least one other state. Actionscan be controlled by policies and/or roles associated with the node andkeyed off of the lifecycle state (e.g., state can be a property of anode) to allow certain classes of users/processes privileges indifferent states. TABLE 6 Exemplary Lifecycle in Various EmbodimentsCURRENT STATE ACTION(S) ROLE(S) NEXT STATE Start Draft Draft SubmitCreator Ready for Approval Ready for Approval Accept Approver PublishedReady for Approval Reject Approver Draft Published Retire Editor,Retired Creator Published Update Creator DraftThe exemplary lifecycle in FIG. 2 begins at Start state 202 which has anunrestricted transition to the next state in the lifecycle, the Draftstate 204. A transition can be unrestricted or restricted to a set ofuser(s), group(s) and/or role(s). In aspects of these embodiments, arole can be delegated to a user through delegated administration. By wayof illustration, approval capabilities can be based on capabilities in adelegated administration model. In one embodiment, a restriction canprovide that only certain authorized users/processes can bring about atransition to the next state. In various embodiments, a state change canbe initiated by a user interacting with the node through a tool and/orby a process interacting with the node through the VCR API. In certainaspects of these embodiments, the current state of a node is a propertyof the node. By way of an example, modifying the state property (e.g.,changing it from “Start” to “Draft”, assuming the user/process isauthorized to do so), can cause attendant lifecycle processing to takeplace, such as performing actions defined on the transition.

The news article can be modified by user(s) and/or process(es) while inthe Draft state and then submitted for approval. By way of an example, auser can check-out the news article (assuming it is under versioncontrol), modify it, and then check-in the article with the changes.Before checking the article in, the user can change the state propertyfrom “Draft” to “Ready for Approval” in order to bring about atransition to the Ready for Approval 208 state. By way of a furtherillustration, a user interface can present a button or a menu optionthat a creator can be selected when the user has finished editing thearticle. Once selected, the article can be automatically submitted tothe lifecycle where it can progress to the next state. In thisillustration, the transition through decision point D1 206 to the Readyfor Approval state is constrained to users in the Creator role. Thus,only a user/process that created the article can cause the article totransition into the Ready for Approval state.

The transition from Draft to Ready for Approval also has an accompanyingaction, Submit. By way of an example, this action can cause anotification to be sent to those interested in reviewing articles forapproval. Alternatively, or in addition to this, the news article can beassigned to users/groups/roles. In this way, users/processes that are inthe assigned users/groups/roles can review it while it is in theReadyfor Approval state. From the Ready for Approval state, there is atransition through decision point D2 210. The D2 decision pointspecifies that a user/process in the Approver role can cause atransition to the Draft state 204 or to the Published state 212. If thetransition is to the Draft state, the action associated with thetransition will be to Reject the article. A rejected article will repeatthe lifecycle path from Draft to Ready for Approval. If the transitionis to the Published state, however, the action will be to Accept thearticle. Once the article is in the Published state, a user/process inthe role of Editor or of Creator can cause a transition to the Retiredstate 216. A user in the role of Creator can cause a transition to theDraft state. Transitioning from the Published state to the Draft statecauses an Update action whereas transitioning from the Published stateto the Retired state causes a Retire action.

In aspects of these embodiments, roles can be organized into a rolehierarchy such that superior roles can skip state transitions requiredof inferior roles. By way of illustration, suppose the Approver role wassuperior to the Creator role. If the current lifecycle state of thearticle was Draft, a user in the role of Approver could skip the Readyfor Approval state and transition the article all the way to thePublished state. In one embodiment, actions associated with the decisionpoints D1 and D2 could be automatically invoked even though the Readyfor Approval state was skipped.

In various embodiments and by way of illustrations, lifecycles can bedefined using a text editor and/or an IDE. From a text editor a user cancreate a full lifecycle definition in a language (e.g., XML). In agraphical environment, a user can create different states and thenconnect them together to represent transitions. In an embodiment, agraphical depiction of a lifecycle can appear as in FIG. 2. Graphicalrepresentations of states and decision nodes can be placed onto an IDEcanvas and connected to form transitions. Property sheets associatedwith the graphical objects can allow a user to interactively specifyroles and actions associated with states and/or transitions. In aspectsof these embodiments, a user can easily switch between graphical andtextual representations of a lifecycle since both representations areequivalent.

In various embodiments, third party lifecycle engines can be invoked.This allows additional functionality to be seamlessly incorporated intothe lifecycle model. In one embodiment, this can be accomplished fromwithin a lifecycle through lifecycle actions. In another embodiment,third party lifecycles can be invoked through a callback mechanism. Byway of illustration, the VCR API can invoke a third party lifecycle inresponse to certain events, such as when a content node/scenario hasbeen modified and/or its state property has changed. In thisillustration, a process which implements a third party lifecycle canregister to receive callbacks when these events occur. The callbacknotification can also include the VCR node identifier and optionallycontext information such as information about the user/process thatcaused the event.

In various embodiments, lifecycles can be utilized from other processes.The VCR API includes a lifecycle interface to allow access to a node'slifecycle definition. In addition, the lifecycle interface allows aprocess to drive a node through the lifecycle by providing functionalitysuch as the ability to ascertain a node's current state, place the nodein a new state based on transition choices available from its currentstate, and invoke actions associated with a state transition.

FIG. 3 is an illustration of an exemplary external scenario that invokesa lifecycle in various embodiments. From an IDE, a user can create avisual representation of a scenario as depicted in FIG. 3. In thisillustration, the scenario includes a starting point 302 icon followedby a client request control icon 304 that represents a process forreceipt of a client request. After the request is received, the scenarioenters a “while” loop 306. Within the loop, a lifecycle control icon 308representing a VCR lifecycle causes the associated lifecycle to beinvoked. The lifecycle control can have associated properties thatidentify the lifecycle and the node that it will drive through thelifecycle. In aspects of these embodiments, a control can be a Java™control. The lifecycle control can drive the node through the lifecycleusing the lifecycle interface of the VCR API. After the lifecycle hascompleted, the scenario invokes a notification control 310 that cancause a notification of lifecycle completion to be sent to varioususer/process.

Various embodiments of the system include a version control capabilitythat is available for nodes such that a history of states is maintainedover the lifetime of a node. In various embodiments, one version of anode is considered the published version. In certain aspects of theseembodiments, versions are given names (or other suitable identifiers)and can be stored or accessed via a version list associated with theparticular node. In aspects of these embodiments, the VCR can providesupport for versioning if the repository in which the node is persisteddoes not.

In various embodiments, a version of a node can also includeidentification of the user/process that last modified the version and adescription or comment. A node under version control can be moved orcopied within the VCR. In various embodiments, version history travelswith the node during a move or a copy. When the user or a process movesa content node the history of that node moves with it. In case of a rollback, parent version of the roll back can be indicated in the history.In various embodiments, a node's version can be “rolled back” (i.e.,restored) to a previous version. In aspects of these embodiments, uponroll back the selected content node version to restore becomes thelatest version of the content node. In certain of these embodiments, therolled back version is automatically given a new version identifier(e.g., old version number+1).

Each node can have a lock (e.g., semaphore or other suitable means forcontrolling access to the node). Locks prevent a node from beingmodified by more than one user/process at the same time. When a node ischecked-out of version control, the user acquires the lock. Lockacquisition prevents others from checking-out versions associated withthe node until it is checked-in. Locks can be employed on the node levelor on the version level. If version-level locks are employed, it ispossible for more than one version of a node to be checked-out at thesame time. Version control can be turned on/off for a given node,repository, and/or VCR. In one embodiment, a node that does not utilizeversion control has only a single version in its version list.

Versioning includes the ability for a user or a process to check-out anode version for editing. By way of illustration, a user can click on anitem in a tree browser view of a VCR (see FIG. 4 and accompanying text).In aspects of these embodiments, a user or process can choose whichversion of a node to check out. The tree browser can display (e.g., viaa pop-up menu or tool tip) the following information for each version:version number/identifier, date version was last saved, the user/processthat performed the last save, and optional comment(s). In variousembodiments, a user can select the version to check-out by interactivelybrowsing the version history of a particular node with the aid of a userinterface such as a tree browser. In one embodiment, the most recentversion of a node is checked-out by default if the version is notspecified.

In one embodiment, a user interface can provide a rendering of a node'sproperties. For example, a user can select an ‘Edit Content’ button inorder to edit the node's properties. This action can attempt tocheck-out the node if it is not already checked-out. In variousembodiments, a given user's checked-out nodes appear in the user'sworkspace (see FIG. 4). The user can save their work until check-intime. In various embodiments, nodes that are “saved” do not changeversions or produce a version increment. From other users' perspectivethe node is still checked-out. Once a user has finished editing, anychanges can be discarded or checked into the VCR.

Upon check-in, a new version of the node is available in the system. Invarious embodiments, checking-in a node causes the node to appear in theVCR but not in the user's workspace. A user/process can enter adescription of the changes made to the node during check-in time. Thedescription can be saved along with the version. Checking a node intothe workspace also causes the associated lock to be released (so thatothers can edit) and, if versioning is turned on, creates a new versionof the node. However, it the user merely saves their work rather thanchecking it in, the node will remain in the workspace and a new versionwill not be generated. In aspects of these embodiments, if a lifecycleis associated with the node, checking the node in can submit the node tothe lifecycle.

By way of a illustration and with reference to FIG. 2, a user in therole of an Creator can submit a news article for approval by changingthe news article's state to “Ready for Approval” and then checking itin. In one embodiment, a drop-down list of states to which the stateproperty can be assigned is made available to the user. The drop-downlist can be filtered based on the user's role and/or the stage of thelifecycle. After check-in, the workspace of a user in the role ofApprover updates to show the news article as an item assigned to theuser. In various embodiments, the Approver could also receive an alert(e.g., e-mail, instant message, page, etc.) to indicate that the newsarticle is available for review. If the approver chooses to edit thenews article, the approver can check it out. Once the approver acquiresthe lock, this item will disappear from the ‘Assigned Items’ part of theworkspace of everyone else in the Approver role.

In various embodiments, a user/process can navigate to a node andperform a delete action. In one embodiment, deleting a node changes itsstate (e.g., to Retired or Deleted). A user can view all deleted nodesat a later time and choose to permanently delete them or to un-deletethem. In another embodiment, deleting a node permanently removes it fromthe VCR. In one embodiment, a node can be deleted regardless of itslifecycle state. In one embodiment, a node cannot be deleted if it ischecked-out. In one embodiment, deleting a node causes all of the node'schildren to be deleted. In one embodiment, only a node's checked-inchildren are deleted. In yet another embodiment, a deleted node (and,optionally, its children) can be un-deleted.

FIG. 4 is an exemplary user interface in various embodiments of theinvention. By way of an example, a user interface can include one ormore of the following: 1) a graphical user interface (GUI) (e.g.,rendered with Hypertext Markup Language); 2) an ability to respond tosounds and/or voice commands; 3) an ability to respond to input from aremote control device (e.g., a cellular telephone, a PDA, or othersuitable remote control); 4) an ability to respond to gestures (e.g.,facial and otherwise); 5) an ability to respond to commands from aprocess on the same or another computing device; and 6) an ability torespond to input from a computer mouse and/or keyboard. This disclosureis not limited to any particular user interface. Those of skill in theart will recognize that many other user interface embodiments arepossible and fully within the scope and spirit of this disclosure.

A user interface according to various embodiments and by way ofillustration can include an interactive graphical tree browser as iswell known in the art to allow users to explore and interact with theVCR and their workspace. A tree browser presents a hierarchical view ofnodes and schemas. The indentation level of a node indicatesparent/child relationships. In various embodiments, the tree browser canpresent one or more views of the VCR. These views can include (but arenot limited to), published nodes, unpublished nodes, retired nodes,deleted nodes, assigned nodes, locked nodes, and nodes waiting forapproval. In aspects of these embodiments, a user can customize the treebrowser to include one or more of these views. The views can bepresented as separate trees or as a merged tree. In various embodiments,views can be automatically customized to particular user(s). Forexample, roles and/or polices that adorn nodes can be used to filter theview. By way of illustration, the assigned items view and waiting forapproval view will only show nodes that are applicable to a given user.In one embodiment, this can be accomplished by examining roles inlifecycle transitions and filtering out nodes for lifecycles that agiven user cannot interact with.

By way of illustration, a tree browser can expose VCR 400, the federatedroot. It contains two repositories (Neptune 402 and Pluto 412) and aPublic hierarchy node 426. In various embodiments nodes can be decoratedwith a folder or related visual symbol to indicate their purpose. Inaspects of these certain embodiments, selection of a folder icon orhierarchy node name causes the contents of the node to expand beneath itin the tree. In further aspects of these embodiments, selection of anytype of node can allow a user to edit the properties of the node. In oneembodiment, schemas can be defined anywhere in the VCR, includingdirectly beneath the federated root (not shown). Schemas that are notdefined in a repository (e.g., 428, 430 and 434) are considered virtualin various embodiments. The Neptune repository 402 contains tworepository nodes: Press Releases 404 and Old Schemas 408. Press releasescontains a content node named Japan Account 406, which is currentlylocked (e.g., checked-out) as indicated by the padlock icon next to itsname. Only the user who has checked-out the node can edit it. Others canoptionally view it depending on roles and/or privileges. The Old Schemashierarchy node contains a schema named Account Schema 410 which iscurrently unlocked. In aspects of these embodiments, a node's propertiescan be viewed by selecting the node in the tree browser. If the selectednode is not locked, the system can automatically attempt to obtain alock on behalf of the user.

The Pluto repository includes a schema 414 and two top-level hierarchynodes (416, 418). One of the hierarchy nodes, 2003 Memos 416, has afolder symbol that is a solid color, the other has an outline of afolder symbol 418. In one embodiment, a special visual symbol (e.g., asolid folder icon) can indicate to a user that the hierarchy node has aschema and/or a lifecycle associated with it. In various embodiments,associating a schema and/or a lifecycle with a hierarchy node results inthe schema and/or lifecycle being imposed on or inherited by thechildren of the hierarchy node. The 2004 Memos hierarchy node containsanother hierarchy node 420, an unlocked content node 422 and a lockedcontent node 424.

In various embodiments, the user interface can provide a logicalWorkspace folder 436 that provides quick access to a user's new,checked-out and assigned items. Assigned items are those items which areassigned to one or more users, groups and/or roles according to alifecycle or some other suitable means. In this illustration, there aretwo nodes assigned to the user: Japan Account 444 and Internal MemoSchema 446. The user has checked-out Japan Account node since it appearsin the VCR tree with a padlock beside it unlike the Internal Memo Schemawhich is not currently checked-out. The user has not checked-out theStaff Change schema 434 since it does not appear in their Workspace(i.e., another user or process has checked it out). In variousembodiments, by selecting the Staff Change schema 434 the user candiscover who holds the lock and when they obtained it.

In various embodiments and by way of a further illustration, new nodescan be created. Newly created nodes can appear in the workspace of theuser that created them until they are published in the VCR. Aspects ofcertain of these embodiments allow a user to create new nodes through auser interface that enables the user to select in which VCR, repositoryor hierarchy node the new node will reside. The user can indicatewhether a version history should be maintained for the new node and canadd properties to the it or base its properties on a schema. A lifecyclefor the new node can also be specified. A tree browser can be updated toreflect the addition of the new node.

FIG. 5 is an exemplary illustration of objects/interfaces that can beused in connecting a repository to a VCR in various embodiments of theinvention. Although this diagram depicts components as logicallyseparate, such depiction is merely for illustrative purposes. It will beapparent to those skilled in the art that the components portrayed inthis figure can be arbitrarily combined or divided into separatesoftware, firmware and/or hardware. Furthermore, it will also beapparent to those skilled in the art that such components, regardless ofhow they are combined or divided, can execute on the same computingdevice or can be distributed among different computing devices connectedby one or more networks or other suitable communication means.

The RepositoryManager 502 can serve as an representation of a VCR froman application program's 500 point of view. In aspects of theseembodiments, the RepositoryManager attempts to connect all availablerepositories to the VCR (e.g., 512-516); optionally with user or processcredentials. In various embodiments, this can be based on the Java™Authentication and Authorization Service (available from SunMicrosystems, Inc.). Those of skill in the art will recognize that manyauthorization schemes are possible without departing from the scope andspirit of the present disclosure. Each available content repository isrepresented by an SPI Repository object 506-510. The RepositoryManagercan invoke a connect() method on the set of Repository objects. Invarious embodiments, the RepositoryManager return a list of repositorysession objects to the application program, one for each repository forwhich a connection was attempted. Any error in the connection procedurecan be described by the session object's state. In another embodiment,the RepositoryManager can connect to a specific repository given therepository name. In various embodiments, the name of a repository can bea URI (uniform resource identifier).

FIG. 6 is an exemplary illustration of objects/interfaces that can beused as service model in various embodiments of the invention. Althoughthis diagram depicts components as logically separate, such depiction ismerely for illustrative purposes. It will be apparent to those skilledin the art that the components portrayed in this figure can bearbitrarily combined or divided into separate software, firmware and/orhardware. Furthermore, it will also be apparent to those skilled in theart that such components, regardless of how they are combined ordivided, can execute on the same computing device or can be distributedamong different computing devices connected by one or more networks orother suitable communication means.

Referring to FIG. 6, a dashed arrow indicates that the object/interfacefrom which the arrow emanates can produce at run-time objects/interfacesto which the arrow points. A Ticket 602 is an API level object/interfacethat provides access to VCR service object/interfaces:, NodeOps 604,WorkspaceOps 606 and SearchOps 608. Each repository connected to the VCRprovides implementations of certain of these objects/interfaces as partof the SPI. A Ticket 602 object/interface is intended to belight-weight. As such, one or more may be created and possibly cachedfor each application/process accessing the VCR. A ticket can utilize auser or a process's credentials to authorize a service. In variousembodiments, a ticket can be an access point for NodeOps 604,WorkspaceOps 606, and SearchOps 608.

By way of illustration, repository 622 provides NodeOps 610,WorkspaceOps 612 and SearchOps 614. Repository 624 provides NodeOps 616,WorkspaceOps 618 and SearchOps 620. API level objects/interfacescommunicate with their corresponding SPI level objects/interfaces. Inthis way, an operation on an API-level object can be distributed to eachrepository such that each repository can work in parallel to perform therequested operation. Accordingly, an operation that might take onaverage time M*N to perform on all repositories sequentially in theorymight only require time M, where N is the number of repositories in theVCR.

The NodeOps 604 provides create, read, update, delete methods for nodesand node properties in the VCR. In aspects of these embodiments, nodesand properties can be operated on based on an identifier, a path in theVCR or through any other suitable relative or absolute reference. Whenthe API NodeOps 604 receives a request to perform an action, it can mapthe request to one or more SPI NodeOps (610, 616) which in turn fulfillthe request using their associated repositories. In this way,applications and libraries utilizing the API see a single VCR ratherthan individual content repositories. NodeOps functionality exposed inthe API can include the following:

-   -   Update a given node's properties and property definitions.    -   Copy a given node to a new location in a given hierarchy along        with all its descendants.    -   Create a new content node underneath a given parent.    -   Create a new hierarchy node underneath a given parent.    -   Perform a full cascade delete on a given node.    -   Retrieve all the nodes in a given node's path including itself.    -   Retrieve content node children for the given parent node.    -   Retrieve hierarchy node children for the given parent node.    -   Retrieve a node based on its ID.    -   Retrieve a node based on its path.    -   Retrieve the children nodes for the given hierarchy node.    -   Retrieve the parent nodes for the given hierarchy node.    -   Retrieve all the nodes with a given name.    -   Retrieve the Binary data for given node and property ids.    -   Moves a node to a new location in the hierarchy along with all        its descendants.    -   Renames a given node and implicitly all of its descendants        paths.    -   Get an iterator object which can be used to iterate over a        hierarchy.

In various embodiments, WorkspaceOps 606 exposes services forversioning, including the services to check-in/check-out nodes,node/property locking, access node version history, lifecyclemanipulation, labeling, and jobs. When the API WorkspaceOps 606 receivesa request to perform an action, it can map the request to one or moreSPI WorkspaceOps (612, 618) which in turn fulfill the request usingtheir associated repositories. WorkspaceOps functionality exposed in theAPI can include:

-   -   check-in: Unlocks the node and saves the node along with it's        working version.    -   check-out: Locks the node such that only the user/process that        locked it may save or check it in and creates a new working        version.    -   copy: Recursively copies the published source node to the        destination.    -   create: Creates a new Node and also a working version for it, if        attached to the node.    -   delete: Deletes a node version with the given version.    -   get: Gets the Node at the given path.    -   get versions: Returns all versions for the given Virtual Node.    -   save: Saves the node and the working version of the node (if        attached to the node), which is the current version on the node.    -   submit: Submits the node to it's life cycle.

In various embodiments, SearchOps 608 provides API searching servicesfor retrieving nodes, properties, and/or property values throughout theentire VCR based on one or more search expressions. When the APISearchOps 608 receives a request to perform an action, it can map therequest to one or more SPI SearchOps (614, 620) which in turn fulfillthe request using their associated repositories. The API SearchOps 608combines the search results from each SPI SearchOps into a result set.In various embodiments, result sets can be refined by performing afurther searches on the items in the result set.

Search expressions can include (but are not limited to) one or morelogical expressions, Boolean operators, nested expressions, variables,identifiers node names, function/method invocations, remote procedurecalls, mathematical functions, mathematical operators, string operators,image operators, and Structured Query Language (SQL). Search expressionscan also include support for natural language queries, keywordsearching, fuzzy logic, proximity expressions, wildcard expressions, andranging search types. In various embodiments, the result set can betailored according to roles/policies in effect on the items that satisfythe search expressions. Those items which a user/process does not havepermission to view can be filtered during the search or after theresults have been gathered.

In aspects of these embodiments, search results can be ranked accordingto ranking algorithms and criteria. In one embodiment, a rankingalgorithm can rank the result set according to what extent items in theresult set satisfy the search expression(s). It will be apparent tothose of skill in the art that many other ranking algorithms arepossible and fully within the scope and spirit of the presentdisclosure. In various embodiments, multiple ranking algorithms can beapplied to the result set. In one embodiment, the ranking criteria for agiven ranking algorithm can be adjusted by a user/process.

In various embodiments, jobs provide the ability to perform VCRoperations on sets of nodes. By way of illustration, a job can be usedto check-in and check-out a set of nodes as a group, or send a group ofnodes through a lifecycle together. In aspects of these embodiments, ajob identifier and/or a label can be associated with a node to indicateits inclusion in a particular job and/or label set. In one embodiment,if a job becomes ready for approval, all nodes in the job will reachthis state. In various embodiments, a label can be used to tag arepository or a group of nodes. By way of illustration, this provides away to refer to a set of nodes with different versions. By way offurther illustration, labels can be used to in search expressions.

In various embodiments, information in the VCR can be exported in anexternal format. In aspects of these embodiments, the external formatcan be XML or another suitable language/representation (e.g., HTML,natural language, a binary file) that can preserve the hierarchicalstructure of the information. Exporting of all or some of the VCR nodesallows “snapshots” of the VCR for backing-up the VCR, transportinginformation in the VCR to another repository, and reloading the nodes ata later date. In various embodiments, a node and all of its childrenwill be exported by an export process. By way of an example, if thefederated root was chosen to be exported, the entire VCR would beexported. By way of a further example, an export process can recursivelytraverse the VCR (e.g., depth-first or bread-first traversal),serializing information associated with each node that is visited (e.g.,content, hierarchy and schema nodes). Aspects of these embodiments havea “preview” mode where it is reported what information (e.g., nodes,lifecycles, roles, policies) would be exported.

In various embodiments, an import process can do the work of the exportprocess in reverse by de-serializing each node (and other information)and adding it at the appropriate place in the VCR namespace. In anotherembodiment, the import process can install nodes beneath a chosen noderather then in their original location. As with the export process,aspects of these embodiments have a “preview” mode where it is reportedwhat information (e.g., nodes, lifecycles, roles, policies) would beimported into the VCR. In addition to node properties, variousembodiments allow the export and import of version history, roles and/orpolicies associated with content and schema nodes.

FIG. 7 is an exemplary illustration of content creation while VCRcontent services are disabled in accordance to various embodiments ofthe invention. Although this diagram depicts components as logicallyseparate, such depiction is merely for illustrative purposes. It will beapparent to those skilled in the art that the components portrayed inthis figure can be combined or divided into separate software, firmwareand/or hardware components. Furthermore, it will also be apparent tothose skilled in the art that such components, regardless of how theyare combined or divided, can execute on the same computing device or canbe distributed among different computing devices connected by one ormore networks or other suitable communication means.

FIG. 7 shows a VCR 700 with two integrated repositories (714, 716) andan integrated third party content management system 718. Although notdepicted, each of the subsystems (714-718) can implement an SPI thatallows for its integration into the VCR. Also illustrated are contentservices provided by the VCR including user workspace management 706,content versioning 708 and lifecycle management 710. In addition tofederation, the VCR can provide one or more of its content services tosubsystems that lack them. By way of illustration, if repository Repo1does not natively support versioning, the VCR can automatically providethis service for nodes in that repository.

Box 702 represents one or more content administration tools which can beused to create, modify and delete information in the VCR. These toolscan take advantage of the VCR's content services. Box 704 represents oneor more tools that can operate on repositories without the need forcontent services. By way of example, these can include bulk contentloaders, content searching tools and content tags. A content manager APIcomponent 712 can be used to manage interaction between the VCR and itsintegrated subsystems.

FIG. 7 illustrates the creation of a content node wherein the VCR'scontent services are not enabled. Box 720 represents the content nodenamed FiscalPlan located in the VCR at /Repo1/FiscalPlan and stored inrepository Repo1. The node also has default system proprieties, e.g.Created By, Created Date, Node Status, and Node type. The node type is aschema called FiscalPlanType which has properties Fiscal Year andCategory. In this instance, these properties have been set to 2003 and“Finance,” respectively. Notice also that the Node Status is“Published.”

FIG. 8 is an exemplary illustration of content creation while VCRcontent services are enabled in accordance to various embodiments of theinvention. This example is similar to that in FIG. 7, however contentservices are enabled in the VCR. The same content node /Repo1/FiscalPlanis created but using the content administration tools (which utilizecontent services). The system first creates a content item in Repo1containing system properties as before. However, the schema-definedproperties are stored in the VCR as a first version of the node ratherthan in Repo1, since Repo1 has no versioning capability. In addition toa version number, the node now also includes a lifecycle status toindicate which lifecycle state the node is in. In this example, thenode's lifecycle status is “Draft.” The system can also lock version 1for the user who created it and provide access to the node through thatuser's workspace. When the user checks the node in, it is submitted toits lifecycle (if any).

FIG. 9 is an exemplary illustration of modifying a node in the VCR whilecontent services are enabled in accordance to various embodiments of theinvention. This FIG. follows from the FIG. 8 discussion above. In thisillustration, the node /Repo1/FiscalPlan is checked out by a user, whichhas the effect of creating a new version (version 2) in the VCR, lockingthe new version, and assigning it to the user. Here, the user haschanged the lifecycle status to “ReadyForApproval.” When the node ischecked in, its schema-defined properties are saved to version 2. Inaddition, the system releases the lock and submits the node to itslifecycle. By way of illustration, this may have to effect of placingthe node in the workspaces of users in a given role (e.g., the publisherrole).

FIG. 10 is an exemplary illustration of publishing a node in the VCRwhile content services are enabled in accordance to various embodimentsof the invention. This figure follows from the FIG. 9 discussion above.In this illustration, the node /Repo1/FiscalPlan is again checked out bya user, which has the effect of creating a new version (version 3) inthe VCR, locking the new version, and assigning it to the user. Here,the user has changed the lifecycle status to “Published.” When the nodeis checked in, the schema-defined properties are saved to version 3. Inaddition, the system unlocks the node and publishes its schema-definedproperties and the Node Type from version 3 to Repo1.

FIG. 11 is an exemplary illustration of retiring a node in the VCR whilecontent services are enabled in accordance to various embodiments of theinvention. Following from FIG. 10, the node /Repo1/FiscalPlan is againchecked out by a user, which has the effect of de-publishing it andcreating a new version (version 4) in the VCR, locking the new version,and assigning it to the user. Here, the user has changed the lifecyclestatus to “Retired.” When the node is checked back in, theschema-defined properties are saved in the VCR to version 4 and the nodeis unlocked. In addition, the system removes (i.e. de-publishes) thenode's schema-defined properties and its Node Type as found in Repo1.

Various embodiments may be implemented using a conventional generalpurpose or a specialized digital computer or microprocessor(s)programmed according to the teachings of the present disclosure, as willbe apparent to those skilled in the computer art. Appropriate softwarecoding can readily be prepared by skilled programmers based on theteachings of the present disclosure, as will be apparent to thoseskilled in the software art. The invention may also be implemented bythe preparation of integrated circuits or by interconnecting anappropriate network of conventional component circuits, as will bereadily apparent to those skilled in the art.

Various embodiments include a computer program product which is astorage medium (media) having instructions stored thereon/in which canbe used to program a computing device to perform any of the featurespresented herein. The storage medium can include, but is not limited to,any type of physical media including floppy disks, optical discs, DVDs,CD-ROMs, microdrives, magneto-optical disks, ROMs, RAMs, EPROMs,EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic or optical cards,nanosystems (including molecular memory ICs), or any type of media ordevice suitable for storing instructions and/or data. Variousembodiments include a computer program product that can be transmittedover one or more public and/or private networks wherein the transmissionincludes instructions which can be used to program a computing device toperform any of the features presented herein.

Stored on any one of the computer readable medium (media), the presentinvention includes software for controlling both the hardware of thegeneral purpose/specialized computer or microprocessor, and for enablingthe computer or microprocessor to interact with a human user or othermechanism utilizing the results of the present invention. Such softwaremay include, but is not limited to, device drivers, operating systems,execution environments/containers, and applications.

The foregoing description of the preferred embodiments of the presentinvention has been provided for purposes of illustration anddescription. It is not intended to be exhaustive or to limit theinvention to the precise forms disclosed. Many modifications andvariations will be apparent to the practitioner skilled in the art.Embodiments were chosen and described in order to best explain theprinciples of the invention and its practical application, therebyenabling others skilled in the art to understand the invention, thevarious embodiments and with various modifications that are suited tothe particular use contemplated. It is intended that the scope of theinvention be defined by the following claims and their equivalents.

1. A method for submitting information to a lifecycle in a virtualcontent repository (VCR), comprising: defining the lifecycle wherein thedefinition includes a plurality states and one or more transitions tointerconnect and impose an order on the plurality of states; providingto a first process access to the lifecycle wherein the first process cancause the information to transition from a first state of the pluralityof states to a second state of the plurality of states according to afirst transition of the one or more transitions; wherein the informationis accessible through a logical namespace that encompasses the VCR; andwherein the information can include at least one of: content and schemainformation.
 2. The method of claim 1 wherein the step of providingaccess to the lifecycle includes: implementing an ApplicationProgramming Interface (API) wherein the API exposes functionality tocontrol the lifecycle.
 3. The method of claim 1, further comprising:defining an action associated with one of: a state in the plurality ofstates, and a transition in the one or more transitions.
 4. The methodof claim 3 wherein: the action can be constrained by at least one of: apolicy, a role, and a capability.
 5. The method of claim 3 wherein: theaction can include one of: a function/method call, a remote procedurecall, inter-process communication, intra-process communication,interfacing with a hardware device, checking the information into/out ofversion control, processing the information, providing a notification toa user.
 6. The method of claim 1 wherein: a transition in the one ormore transitions can be constrained to at least one of: a user, a groupof users, and a role.
 7. The method of claim 1 wherein: the informationtransitions through a subset of the plurality of states.
 8. The methodof claim 1, further comprising: maintaining a version history to trackchanges to the information.
 9. The method of claim 1, furthercomprising: integrating a plurality of repositories into the VCR. 10.The method of claim 9, wherein the step of integrating includes:implementing a service provider interface (SPI) that is compatible withthe VCR.
 11. A system for submitting information to a lifecycle,comprising: a virtual information repository (VCR); plurality ofrepositories integrated into the VCR; a lifecycle definition including aplurality states and one or more transitions to interconnect and imposean order on the plurality of states; a first process access to thelifecycle wherein the first process can cause the information totransition from a first state of the plurality of states to a secondstate of the plurality of states according to a first transition of theone or more transitions; wherein the information is accessible through alogical namespace that encompasses plurality of repositories; andwherein the information can include at least one of: content and schemainformation.
 12. The system of claim 11 wherein: the first process canaccess the lifecycle through an Application Programming Interface (API)wherein the API exposes functionality to control the lifecycle.
 13. Thesystem of claim 11, further comprising: an action associated with oneof: a state in the plurality of states, and a transition in the one ormore transitions.
 14. The system of claim 13 wherein: the action can beconstrained by at least one of: a policy, a role, and a capability. 15.The system of claim 13 wherein: the action can include one of: afunction/system call, a remote procedure call, inter-processcommunication, intra-process communication, interfacing with a hardwaredevice, checking information into/out of version control, processing theinformation, providing a notification to a user.
 16. The system of claim11 wherein: a transition in the one or more transitions can beconstrained to at least one of: a user, a group of users, and a role.17. The system of claim 11 wherein: the information transitions througha subset of the plurality of states.
 18. The system of claim 11, furthercomprising: a version history to track changes to the information. 19.The system of claim 11, further comprising: a service provider interface(SPI) that is compatible with the VCR implemented by the plurality ofrepositories.
 20. A machine readable medium having instructions storedthereon that when executed by one or more processors cause a system to:define a lifecycle wherein the definition includes a plurality statesand one or more transitions to interconnect and impose an order on theplurality of states; provide to a first process access to the lifecyclewherein the first process can cause the information to transition from afirst state of the plurality of states to a second state of theplurality of states according to a first transition of the one or moretransitions; wherein the information is accessible through a logicalnamespace that encompasses the VCR; and wherein the information caninclude at least one of: content and schema information.
 21. The machinereadable medium of claim 20, further comprising instructions that whenexecuted cause the system to: implement an Application ProgrammingInterface (API) wherein the API exposes functionality to control thelifecycle.
 22. The machine readable medium of claim 20, furthercomprising instructions that when executed cause the system to: definean action associated with one of: a state in the plurality of states,and a transition in the one or more transitions.
 23. The machinereadable medium of claim 22 wherein: the action can be constrained by atleast one of: a policy, a role, and a capability.
 24. The machinereadable medium of claim 22 wherein: the action can include one of: afunction/machine readable medium call, a remote procedure call,inter-process communication, intra-process communication, interfacingwith a hardware device, checking the information into/out of versioncontrol, processing the information, providing a notification to a user.25. The machine readable medium of claim 20 wherein: a transition in theone or more transitions can be constrained to at least one of: a user, agroup of users, and a role.
 26. The machine readable medium of claim 20wherein: the information transitions through a subset of the pluralityof states.
 27. The machine readable medium of claim 20, furthercomprising instructions that when executed cause the system to: maintaina version history to track changes to the information.
 28. The machinereadable medium of claim 20, further comprising instructions that whenexecuted cause the system to: integrate plurality of repositories intothe VCR.
 29. The machine readable medium of claim 28, further comprisinginstructions that when executed cause the system to: implement a serviceprovider interface (SPI) that is compatible with the VCR.
 30. A computerdata signal embodied in a transmission medium, comprising: a codesegment including instructions to define a lifecycle wherein thedefinition includes a plurality states and one or more transitions tointerconnect and impose an order on the plurality of states; a codesegment including instructions to provide to a first process access tothe lifecycle wherein the first process can cause the information totransition from a first state of the plurality of states to a secondstate of the plurality of states according to a first transition of theone or more transitions; wherein the information is accessible through alogical namespace that encompasses the VCR; and wherein the informationcan include at least one of: content and schema information.